home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / dsp / dspgroup / macrosrc.arc / DIF.ASM < prev    next >
Encoding:
Assembly Source File  |  1983-11-17  |  4.9 KB  |  166 lines
  1.  
  2. *DIF - DIGITAL FILTER GENERATOR
  3. *       THE AC, P, T, AND AR1 WILL BE USED (MAYBE XR0 TOO)
  4. *
  5. *    DIF X,S,Y,G,RS,(A-LIST),(B-LIST)
  6. *
  7. *    X IS OPTIONAL INPUT VARIABLE (IF OMITTED AC ASSUMED)
  8. *    Y IS OPTIONAL OUTPUT VARIABLE (IF OMITTED AC IS ASSUMED)
  9. *    S IS STATE VECTOR (SHOULD HAVE ONE WORD PER A/B-LIST ENTRY)
  10. *    G IS THE GAIN (X*G IS INPUT) -13 BIT (+4095 TO -4096)
  11. *    RS IS THE VALUE USED TO SCALE S0 BEFORE OUTPUT (Y) CALCULATION
  12. *        THE VALUE IS IN RIGHT SHIFTS (0 TO 16)
  13. *       PR IS PRECISION OF THE RESULT (0 TO 16, 15, AND 12 ARE THE
  14. *                  SIGNIFICANT VALUES WHEN USED WITH RS=12 OR 15)
  15. *    A-LIST IS A LIST OF 13 BIT CONSTANTS, AN, ... ,A1 (REVERSE):
  16. *        S0 := (X*G+A1*S1+A2*S2+ ... +AN*SN)/2**RS
  17. *    B-LIST IS A LIST OF 13 BIT CONSTANTS, BN, ... ,B0 (REVERSE):
  18. *               Y  := B0*S0+B1*S1+B2*S2+ ... +BN*SN
  19. *               EACH SM -> SM+1 AS ACCESSED ABOVE
  20. *
  21. *    IF A-LIST IS BLANK, ONLY THE B-SIDE (POLES) ARE GENERATED
  22. *               Y  := X*G+B1*S1+B2*S2+ ... +BN*SN   (B0 IS OMITTED)
  23. *        S0 := X (OLD S0-SN-1 TO S1 TO SN)
  24. *    IF B-LIST IS BLANK, ONLY THE A-SIDE (ZEROS) ARE GENERATED
  25. *        S0 := (X*G+A1*S1+A2*S2+ ... +AN*SN)/2**RS
  26. *
  27. *    AR1 AND AR0 (IF A-LIST EMPTY ONLY) ARE DESTROYED.
  28.  
  29.         COPY MACROS.RLSH
  30.  
  31. $1DIF   $MACRO V,P
  32.         LT:P: *-       LOAD THE STATE VAR
  33.         MPYK :V:       TIMES THE COEFF
  34.         $END
  35.  
  36. $2DIF   $MACRO P,AA,B
  37.         $1DIF  :AA:,:P:
  38.         $IF  B.L#=0
  39.         $2DIF :P:,:B:
  40.         $ENDIF
  41.         $END
  42.  
  43. *
  44. *THIS MACRO, DDIF, CAN DO A DOT PRODUCT BETWEEN A VECTOR IN
  45. *  DATA RAM AND CONSTANTS IN PROGRAM ROM. FORM:
  46. *  DIF <FIRST LT POSTFIX>,<LT POSTFIX>,<RAM VECTOR>,<COEFFICIENT LIST>
  47. *  <LT POSTFIX> IS D OR A FOR LOAD T (WITH VECTOR ELEMENTS) USING
  48. *       LTA - ELEMENTS WILL NOT BE MOVED AS A SIDE EFFECT
  49. *       LTD - ELEMENTS WILL BE MOVED, S0/SN MOVED TO S1/SN+1
  50. *  <FIRST LT POSTFIX> IS LIKE <LT POSTFIX>, BUT USED ON FIRST LT
  51. *       ONLY. SOMETIMES MAKES SENSE TO MAKE IT BLANK (AS WELL AS A OR D)
  52. *  <RAM VECTOR> IS THE ADDRESS OF THE LAST ELEMENT IN THE VECTOR
  53. *       (USE AR1 AND *- TO ACCESS ELEMENTS)
  54. *  <COEFFICIENT LIST> IS AN, ... , A0, WHERE EACH IS A 13 BIT CONSTANT
  55. *       (FROM +4095 TO -4096) - THESE ARE IN REVERSE ORDER!!!
  56. *
  57. *  THE FOLLOWING IS FORMED (IN THE AC):
  58. *       P+AC+S0*A0+S1*A1+ ... +SN*AN->AC
  59. *                   OR
  60. *        AC+S0*A0+S1*A1+ ... +SN*AN->AC
  61. *
  62. *  P AND AC MUST BE PRE-INITIALIZED
  63.  
  64. DDIF    $MACRO P0,P,S,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9
  65.         LARK AR1,:S:    LOAD AR1 WITH :S:
  66.         LARP AR1        SELECT AR1
  67.         $IF  A0.L#=0
  68.         $1DIF :A0:,:P0:
  69.         $ENDIF
  70.         $IF  A1.L#=0
  71.         $1DIF :A1:,:P:
  72.         $ENDIF
  73.         $IF  A2.L#=0
  74.         $1DIF :A2:,:P:
  75.         $ENDIF
  76.         $IF  A3.L#=0
  77.         $1DIF :A3:,:P:
  78.         $ENDIF
  79.         $IF  A4.L#=0
  80.         $1DIF :A4:,:P:
  81.         $ENDIF
  82.         $IF  A5.L#=0
  83.         $1DIF :A5:,:P:
  84.         $ENDIF
  85.         $IF  A6.L#=0
  86.         $1DIF :A6:,:P:
  87.         $ENDIF
  88.         $IF  A7.L#=0
  89.         $1DIF :A7:,:P:
  90.         $ENDIF
  91.         $IF  A8.L#=0
  92.         $1DIF :A8:,:P:
  93.         $ENDIF
  94.         $IF  A9.L#=0
  95.         $2DIF :P:,:A9:
  96.         $ENDIF
  97.         APAC            FLUSH TO THE AC
  98.         $END
  99.  
  100. DIF    $MACRO X,S,Y,G,RS,PR,A,B
  101.        $IF  G.L=0
  102.        $ASG 1 TO G.V
  103.        $ENDIF
  104.        $IF  G.V=1
  105.        $IF  X.L#=0
  106.        LAC  :X:,0      LOAD INPUT TO AC
  107.        $IF  A.L=0
  108.        LAR  AR0,:X:    LOAD INPUT INTO AR0
  109.        $ENDIF
  110.        $ELSE
  111.        $IF  A.L=0
  112.        SACL XR0,0      STORE AC IN TEMP
  113.        LAR  AR0,XR0    LOAD INPUT INTO AR0
  114.        $ENDIF
  115.        MPYK 0          INIT P
  116.        $ELSE
  117.        $IF  X.L=0
  118.        SACL XR0,0      SAVE IN TEMP
  119.        $ASG 'XR0' TO X.S
  120.        $ENDIF
  121.        $IF  A.L=0
  122.        LAR  AR0,XR0    LOAD INPUT INTO AR0
  123.        $ENDIF
  124.        ZAC             INIT AC
  125.        LT   :X:        LOAD TEMP
  126.        MPYK :G:        TIMES GAIN
  127.        $ENDIF
  128.        $IF  A.L#=0
  129.        DDIF D,D,:S:+:A.V:-1,:A:
  130.        $IF  RS.L=0     NO SHIFT
  131.        SACL :S:,0      SAVE :S:
  132.        $ELSE
  133.        $IF  RS.V=16    SHIFT IS 16
  134.        SACH :S:,0      SAVE :S:
  135.        $ELSE
  136.        $IF  RS.V=0     NO SHIFT
  137.        SACL :S:,0      SAVE :S:
  138.        $ELSE
  139.        $IF  (RS.V=15)&(PR.V<=15)    SHIFT 15
  140.        SACH :S:,0      SAVE WITH 15 BIT SHIFT
  141.        $ELSE
  142.        $IF  (RS.V=12)&(PR.V<=12)    SHIFT 12
  143.        SACH :S:,4      SAVE WITH 12 BIT SHIFT
  144.        $ELSE
  145.        SACX XR0,0      SAVE WHOLE DOUBLE WORD
  146.        RLSH XR1,:S:,:RS:
  147.        LAC  XR0,16-:RS:
  148.        OR   :S:
  149.        SACL :S:,0      SAVE :S:
  150.        $ENDIF
  151.        $ENDIF
  152.        $ENDIF
  153.        $ENDIF
  154.        $ENDIF
  155.        $IF  B.L#=0
  156.        ZAC             INIT AC TO ZERO
  157.        DDIF ,A,:S:+:B.V:-1,:B:
  158.        $ENDIF
  159.        $ELSE
  160.        DDIF A,D,:S:+:B.V:-1,:B:
  161.        SAR  AR0,:S:
  162.        $ENDIF
  163.        $IF  Y.L#=0
  164.        SACL :Y:,0      STORE OUTPUT
  165.        $ENDIF
  166.        $END